home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / wais / ir / cutil.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  23KB  |  1,000 lines
  1. /* Wide AREA INFORMATION SERVER SOFTWARE    
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.  
  4.   
  5.    3.26.90    Harry Morris, morris@think.com
  6.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  7.    7/19/91  speed up substrcmp by ses@ccgr.technion.ac.il (Simon E Spero)
  8.  *
  9.  * $Log: cutil.c,v $
  10.  * Revision 1.24.1.1  1992/07/11  00:55:47  curtisg
  11.  * Changes for SCO UNIX
  12.  *
  13.  * Revision 1.24  92/03/28  19:53:39  jonathan
  14.  * Removed useless ifdef BSD in cprintf
  15.  * 
  16.  * Revision 1.23  92/03/07  19:44:39  jonathan
  17.  * ANSIfied arguments.
  18.  * 
  19.  * Revision 1.22  92/03/04  16:14:23  jonathan
  20.  * Added include <ctype.h> for isalnum.
  21.  * 
  22.  * Revision 1.21  92/02/21  11:03:15  jonathan
  23.  * Fixed $Log.
  24.  * 
  25.  * Revision 1.20  92/02/21  11:02:02  jonathan
  26.  * Added wais_log_level, RCSIdent
  27.  * 
  28.  * Revision 1.19  92/02/16  21:24:54  jonathan
  29.  * Added code for vprintf, if needed (like for old BSD).
  30.  * 
  31.  * Revision 1.18  92/02/12  14:33:26  morris
  32.  * made string_downcase not die when passed NULL
  33.  * 
  34.  * Revision 1.17  92/02/12  13:16:21  jonathan
  35.  * Added $Log so RCS will put the log message in the header
  36.  * 
  37.  *
  38. */
  39.  
  40. #ifndef lint
  41. static char *RCSid = "$Header: /y/src/wais/wais-8-b5/ir/RCS/cutil.c,v 1.24.1.1 1992/07/11 00:55:47 curtisg Exp curtisg $";
  42. #endif
  43.  
  44. #define _C_C_util_
  45.  
  46. #include "cutil.h"
  47. #include "panic.h"
  48.  
  49. #include <ctype.h>
  50. #include <string.h>
  51.  
  52. #if defined(M_XENIX) && !defined(M_UNIX)
  53. /* perhaps this should be in ustubs.h */
  54. #include <malloc.h>
  55. char* calloc();
  56. #endif /* def M_XENIX */
  57.  
  58. /*----------------------------------------------------------------------*/
  59.  
  60. /*#define MEMORY_ACCOUNTING*/
  61.  
  62. #ifdef MEMORY_ACCOUNTING
  63. #undef s_checkPtr
  64. #define s_checkPtr(ptr) fs_checkPtr(ptr)
  65. static FILE* memRecord = NULL;
  66. static void prepMemAcct _AP((void));
  67. static void 
  68. prepMemAcct()
  69. {
  70.   if (memRecord == NULL)
  71.     memRecord = s_fopen("MemoryAccounting","w");
  72. }
  73. static void flushMemAcct _AP((void));
  74. static void 
  75. flushMemAcct()
  76. {
  77.   fflush(memRecord);
  78. }
  79. #define tickles 0
  80. static char*     badPtr    = (char*)-1;
  81. static size_t    badSize    = -1;
  82. #endif /* def MEMORY_ACCOUNTING */
  83.  
  84. /*----------------------------------------------------------------------*/
  85.  
  86. void
  87. fs_checkPtr(ptr)
  88. void* ptr;
  89. /* If the ptr is NULL, give an error */
  90. { 
  91. #ifdef MEMORY_ACCOUNTING
  92. static char** ptrs = NULL;
  93. long i;
  94. static Boolean  doneSetup = false;
  95. if (doneSetup == false)
  96. {
  97. #ifdef THINK_C
  98. Debugger();
  99. #endif /* def THINK_C */
  100. doneSetup = true;
  101. }
  102. #endif /* def MEMORY_ACCOUNTING */
  103.  
  104.   if (ptr == NULL)
  105.     panic("checkPtr found a NULL pointer");
  106.  
  107. #ifdef MEMORY_ACCOUNTING
  108. /* look for specific ptr (useful when tracking un-freed memory) */
  109. if (ptr == badPtr) warn("checking found bad ptr"); 
  110. /* tickle a memory bug */
  111. if (ptrs == NULL && tickles > 0)
  112.   ptrs = (char**)malloc((size_t)tickles * sizeof(char*));
  113. for (i = 0; i < tickles; i++)
  114. { ptrs[i] = malloc((size_t)5);
  115. }
  116. for (i = 0; i < tickles; i++)
  117. { free(ptrs[i]);
  118. }
  119. #endif /* def MEMORY_ACCOUNTING */
  120.  
  121. }
  122.  
  123. /*----------------------------------------------------------------------*/
  124.  
  125. void*
  126. fs_malloc(size)
  127. size_t size;
  128. /* does safety checks and optional accounting */
  129. { 
  130.   register void* ptr = NULL;
  131.  
  132.   if(!size) return(NULL);
  133.  
  134. #ifdef THINK_C
  135.   ptr = (void*)NewPtr((long)size);
  136.   s_checkPtr(ptr);
  137.   memset(ptr,0,(size_t)size);    /* zero it */
  138. #else  
  139.   ptr = (void*)calloc((size_t)size,(size_t)1);
  140.   s_checkPtr(ptr);
  141. #endif
  142.   
  143. #ifdef MEMORY_ACCOUNTING
  144.   /* look for specific size (useful when tracking un-freed memory) */
  145.   if (size == badSize)
  146.     warn("bad size in malloc");
  147.   
  148.   prepMemAcct();
  149.   fprintf(memRecord,"malloced %lu bytes at %lu\n",size,ptr);
  150.   flushMemAcct();
  151. #endif
  152.  
  153.   return(ptr);
  154. }
  155.  
  156. /*----------------------------------------------------------------------*/
  157.  
  158. void*
  159. fs_realloc(ptr,size)
  160. void* ptr;
  161. size_t size;
  162. /* does safety checks and optional accounting 
  163.    note - we don't know how big ptr's memory is, so we can't ensure
  164.    that any new memory allocated is NULLed!
  165.  */
  166. { 
  167.   register void* nptr = NULL;
  168.   
  169.   if (ptr == NULL)        /* this is really a malloc */
  170.     return(s_malloc(size));
  171.     
  172. #ifdef THINK_C
  173.   nptr = NewPtr(size);        /* need to make a copy */ 
  174.   s_checkPtr(nptr);
  175.   BlockMove(ptr,nptr,size);    /* move the old contents into it */
  176.   DisposPtr(ptr);            /* get rid of the old ones */
  177. #else
  178.   nptr = (void*)realloc(ptr,size);
  179.   s_checkPtr(ptr);
  180. #endif  
  181.    
  182. #ifdef MEMORY_ACCOUNTING
  183.   /* look for specific size (useful when tracking un-freed memory) */
  184.   if (size == badSize) 
  185.     warn("bad size in realloc");
  186.   
  187.   prepMemAcct();
  188.   fprintf(memRecord,"realloced %lu bytes at %lu from %lu\n",size,nptr,ptr);
  189.   flushMemAcct();
  190. #endif
  191.  
  192.   return(nptr);
  193. }
  194.  
  195. /*----------------------------------------------------------------------*/
  196.  
  197. void
  198. fs_free(ptr)
  199. void* ptr;
  200. /* does safety checks and optional accounting */
  201. {
  202. #ifdef MEMORY_ACCOUNTING
  203.   prepMemAcct();
  204.   /* note that the sizeof a pointer is always 4.  If only we could find out
  205.      how much space that pointer was pointing to.  Oh well, this is a place
  206.      holder for now
  207.    */
  208.   fprintf(memRecord,"freed %lu bytes at %lu\n",(size_t)sizeof(ptr),ptr);
  209.   flushMemAcct();
  210.  
  211.   /* look for specific ptr (useful when tracking un-freed memory) */
  212.   if (ptr == badPtr) warn("bad ptr in free");
  213. #endif
  214.  
  215.   if (ptr != NULL)        /* some non-ansi compilers/os's cant handle freeing null */
  216.     {                /* if we knew the size of this block of memory, we could clear it - oh well */
  217. #ifdef THINK_C
  218.       DisposPtr(ptr);
  219. #else
  220.       free(ptr);
  221. #endif
  222.     }
  223. }
  224.  
  225. /*----------------------------------------------------------------------*/
  226.  
  227. char*
  228. s_strdup(s)
  229. char* s;
  230.  
  231. /* return a copy of s.  This is identical to the standard library routine
  232.    strdup(), except that it is safe.  If s == NULL or malloc fails, 
  233.    appropriate action is taken.
  234.  */
  235. {
  236.   unsigned long len;
  237.   char* copy = NULL;
  238.   
  239.   if (s == NULL)        /* saftey check to postpone stupid errors */
  240.     return(NULL);
  241.     
  242.   len = strlen(s);        /* length of string - terminator */
  243.   copy = (char*)s_malloc((size_t)(sizeof(char)*(len + 1)));
  244.   strncpy(copy,s,len + 1);
  245.   return(copy);
  246. }
  247.  
  248. /*----------------------------------------------------------------------*/
  249.  
  250. char*
  251. fs_strncat(dst,src,maxToAdd,maxTotal)
  252. char* dst;
  253.    char* src;
  254.    size_t maxToAdd;
  255.    size_t maxTotal;
  256.  
  257. /* like strncat, except the fourth argument limits the maximum total 
  258.    length of the resulting string
  259.  */
  260. {
  261.   size_t dstSize = strlen(dst);
  262.   size_t srcSize = strlen(src);
  263.   
  264.   if (dstSize + srcSize < maxTotal) /* use regular old strncat */
  265.     return(strncat(dst,src,maxToAdd));
  266.   else
  267.     { size_t truncateTo = maxTotal - dstSize - 1;
  268.       char   saveChar;
  269.       char*  result = NULL;
  270.  
  271.       saveChar = src[truncateTo];
  272.       src[truncateTo] = '\0';
  273.       result = strncat(dst,src,maxToAdd);
  274.       src[truncateTo] = saveChar;
  275.       return(result);
  276.     }
  277. }
  278.  
  279. /*----------------------------------------------------------------------*/
  280.  
  281. char*
  282. fs_strncpy(s1, s2, n)
  283.      char* s1;
  284.      char* s2;
  285.      long n;
  286. /* like strncpy except that it guarentees that the destination string ends with a NULL at position n.
  287.  */
  288. {
  289.   s1[n-1] = '\0';
  290.   return(strncpy(s1, s2, n - 1));
  291. }
  292.  
  293. /*----------------------------------------------------------------------*/
  294.  
  295. typedef long (longfunc) _AP((long c));
  296.  
  297. char*
  298. strtokf(s1,isDelimiter)
  299. char* s1;
  300. longfunc *isDelimiter; /* really *isDelimiter() */
  301.  
  302. /* This function is exactly like strtok, except that instead of passing a 
  303.    delimiter string, you pass a function that decides if a character is 
  304.    a delimiter or not, returning IS_DELIMITER or NOT_DELIMITER respecively.
  305.    Note that passing a NULL delimiter function will cause the last delimiter
  306.    to be used.
  307.  */
  308. {
  309.   static char* searchStr = NULL;
  310.   static longfunc *delimiterFunc;
  311.   long i;
  312.   char* startTok = NULL;
  313.  
  314.   if (s1 != NULL)        /* passing s1 = NULL says use the last pos */
  315.     searchStr = s1;
  316.     
  317.   if (isDelimiter != NULL)
  318.     delimiterFunc = isDelimiter;
  319.    
  320.   if (searchStr == NULL || searchStr[0] == '\0')
  321.     return(NULL);        /* nothing left to search */
  322.     
  323.   if (delimiterFunc == NULL)
  324.     return(NULL);        /* no delimiter to search with */
  325.     
  326.   /* find the start of the next token */
  327.   for (i = 0; searchStr[i] != '\0'; i++)
  328.     { if ((*delimiterFunc)((long)searchStr[i]) == NOT_DELIMITER)
  329.     break;
  330.     }
  331.   
  332.   if (searchStr[i] == '\0') 
  333.     return(NULL);        /* read to end of search string */
  334.   else
  335.     startTok = searchStr + i;    /* remember the starting point for this token*/
  336.     
  337.   /* find the end of the next token */
  338.   for (; searchStr[i] != '\0'; i++)
  339.     { if ((*delimiterFunc)((long)searchStr[i]) == IS_DELIMITER)
  340.     break;
  341.     }
  342.    
  343.   /* if the end is a delimiter (and not just the end of the search string)
  344.      replace it with '\0', and put searchStr just beyond it, otherwise
  345.      put searchStr at the terminator. */
  346.   if (searchStr[i] != '\0')
  347.     { searchStr[i] = '\0';
  348.       searchStr = searchStr + i + 1;
  349.     }
  350.   else
  351.     searchStr = searchStr + i;
  352.    
  353.   return(startTok);
  354. }
  355.  
  356. /*----------------------------------------------------------------------*/
  357.  
  358. char*
  359. strtokf_isalnum(s1)
  360. char* s1;
  361.  
  362. /* 
  363.   This is a partially evaluated version of strtok_f
  364.  */
  365. {
  366.   static char* searchStr = NULL;
  367.   long i;
  368.   char* startTok = NULL;
  369.  
  370.   if (s1 != NULL)        /* passing s1 = NULL says use the last pos */
  371.     searchStr = s1;
  372.     
  373.    
  374.   if (searchStr == NULL || searchStr[0] == '\0')
  375.     return(NULL);        /* nothing left to search */
  376.     
  377.     
  378.   /* find the start of the next token */
  379.   for (i = 0; searchStr[i] != '\0'; i++)
  380.     { if (isalnum(searchStr[i]))
  381.     break;
  382.     }
  383.   
  384.   if (searchStr[i] == '\0') 
  385.     return(NULL);        /* read to end of search string */
  386.   else
  387.     startTok = searchStr + i;    /* remember the starting point for this token*/
  388.     
  389.   /* find the end of the next token */
  390.   for (; searchStr[i] != '\0'; i++)
  391.     { if (!isalnum(searchStr[i]))
  392.     break;
  393.     }
  394.    
  395.   /* if the end is a delimiter (and not just the end of the search string)
  396.      replace it with '\0', and put searchStr just beyond it, otherwise
  397.      put searchStr at the terminator. */
  398.   if (searchStr[i] != '\0')
  399.     { searchStr[i] = '\0';
  400.       searchStr = searchStr + i + 1;
  401.     }
  402.   else
  403.     searchStr = searchStr + i;
  404.    
  405.   return(startTok);
  406. }
  407.  
  408. /*----------------------------------------------------------------------*/
  409.  
  410. #ifdef ANSI_LIKE /* use ansi varargs */
  411.  
  412. long
  413. cprintf(boolean print, char* format, ...)
  414. /* just like printf, but only prints if the first argument = 1 */
  415. {
  416.   va_list ap;            /* the variable arguments */
  417.   if (print == 1)
  418.     { long res;
  419.       va_start(ap,format);    /* init ap */
  420.       res = vprintf(format,ap);    /* print the contents */
  421.       va_end(ap);        /* free ap */
  422.       return(res);
  423.     }
  424.   else
  425.     return(0);
  426. }
  427.  
  428. #else /* use k&r varargs */
  429.  
  430. long
  431. cprintf(va_alist)
  432. va_dcl
  433. /* just like printf, but only prints if the first argument = 1 */
  434. {
  435.   va_list ap;            /* the variable arguments */
  436.   boolean print;
  437.   long res;
  438.  
  439.   va_start(ap);            /* init ap */
  440.  
  441.   print = va_arg(ap,boolean);    /* get the condition */
  442.  
  443.   if (print == 1)
  444.     { char* format = va_arg(ap,char*); /* get the format */
  445.       res = vprintf(format,ap);    /* print the contents */
  446.     }
  447.   else
  448.     res = 0;
  449.  
  450.   va_end(ap);            /* free ap */
  451.  
  452.   return(res);
  453. }
  454.  
  455.   
  456. #endif
  457.  
  458. extern char* log_file_name;
  459. extern FILE* logfile;
  460.  
  461. /* waislog - a new and improved logging facility.
  462.    first two arguments are important, the rest is text.
  463.  
  464.    arg1: priority.  If priority > log_level (some global), output this
  465.    message
  466.  
  467.    arg2: message code.  This is the kind of message (search, retrieval, etc).
  468. */
  469.  
  470. #ifdef ANSI_LIKE /* use ansi varargs */
  471.  
  472. void
  473. waislog(long priority, long message, char* format, ...)
  474. /* just like printf, but prints to the logfile, with PID and time. */
  475. {
  476.   va_list ap;            /* the variable arguments */
  477.  
  478.   if(priority <= wais_log_level) {
  479.  
  480.     if(logfile == NULL && log_file_name != NULL)
  481.       logfile = fopen(log_file_name, "a");
  482.  
  483.     if(logfile) {
  484.       va_start(ap, format);
  485.  
  486.       fprintf(logfile, "%d: %d: %s: %d: ", wais_pid, log_line++, printable_time(), message);
  487.  
  488.       vfprintf(logfile, format,ap); /* print the contents */
  489.       fprintf(logfile, "\n");
  490.       fflush(logfile);
  491.       va_end(ap);        /* free ap */
  492.     }
  493.  
  494.     if(logfile != NULL && logfile != stderr) {
  495.       fclose(logfile);
  496.       logfile = NULL;
  497.     }
  498.   }
  499. }
  500.  
  501. #else /* use k&r varargs */
  502.  
  503. void
  504. waislog(va_alist)
  505. va_dcl
  506. /* just like printf, but prints to the logfile, with PID and time. */
  507. {
  508.   va_list ap;            /* the variable arguments */
  509.   char* format;
  510.   static long line = 0;
  511.   int priority, message;
  512.  
  513.   va_start(ap);            /* init ap */
  514.  
  515.   priority = va_arg(ap, int);
  516.  
  517.   if(priority <= wais_log_level) {
  518.  
  519.     if(logfile == NULL && log_file_name != NULL)
  520.       logfile = fopen(log_file_name, "a");
  521.  
  522.   
  523.     if(logfile) {
  524.       message = va_arg(ap, int);
  525.  
  526.       fprintf(logfile, "%d: %d: %s: %d: ", wais_pid, line++, printable_time(), message);
  527.  
  528.       format = va_arg(ap,char*); /* get the format */
  529.  
  530.       vfprintf(logfile, format,ap); /* print the contents */
  531.       fprintf(logfile, "\n");
  532.       fflush(logfile);
  533.     }
  534.  
  535.     if(logfile != NULL && logfile != stderr) {
  536.       fclose(logfile);
  537.       logfile = NULL;
  538.     }
  539.   }
  540.   va_end(ap);            /* free ap */
  541. }
  542.  
  543. #endif /* ANSI_LIKE */
  544.   
  545. /*----------------------------------------------------------------------*/
  546.  
  547. void
  548. warn(message)
  549. char* message;
  550.  
  551. {
  552. #ifdef THINK_C
  553.   Debugger();
  554. #else
  555.   printf("%s\n<press return to continue>\n",message);
  556.   getchar();
  557. #endif
  558. }
  559.  
  560. /*----------------------------------------------------------------------*/
  561. boolean substrcmp(string1,string2)
  562. char *string1, *string2;
  563. {
  564.   /* compares the strings up until one of then ends.
  565.    * returns true if they are the same, false if not.
  566.    */
  567.   register char *a, *b;
  568.   
  569.   a = string1;
  570.   b = string2;
  571.   
  572.   while (*a && *b) 
  573.     if(*a++ != *b++) 
  574.       return false;
  575.   return true;
  576. }
  577.  
  578. /*----------------------------------------------------------------------*/
  579.  
  580. char *printable_time()
  581. { 
  582.   static char *string;
  583.   time_t tptr;
  584.   time(&tptr);
  585.   string = ctime(&tptr);
  586.   if(string){
  587.     if(string[strlen(string)-1] == '\n')
  588.       string[strlen(string)-1] = '\0';   
  589.     return(string+4);
  590.   }
  591.   else
  592.     return("Time Unknown");
  593. }
  594.  
  595. /*----------------------------------------------------------------------*/
  596.  
  597. char char_downcase(long_ch)
  598. unsigned long long_ch;
  599. {
  600.   unsigned char ch = long_ch & 0xFF; /* just want one byte */
  601.   /* when ansi is the way of the world, this can be tolower */
  602.   return (((ch >= 'A') && (ch <= 'Z')) ? (ch + 'a' -'A') : ch);
  603. }
  604.  
  605. char *string_downcase(word)
  606. char *word;
  607. {
  608.   long i = 0;
  609.  
  610.   if (word == NULL)
  611.     return(NULL);
  612.  
  613.   while(word[i] != '\0')
  614.    { word[i] = char_downcase((unsigned long)word[i]);
  615.      i++;
  616.    }
  617.  
  618.   return(word);
  619. }
  620.  
  621. /*----------------------------------------------------------------------*/
  622.  
  623.  
  624. /* parsing arguments functions */
  625.  
  626. char *next_arg(argc,argv)
  627. int *argc;
  628. char ***argv;
  629.  
  630.      /* Returns NULL when it is out of arguments,
  631.         This side effects both argc and argv.  argc always contains the number
  632.     of arguments left.
  633.     The first returned is the command name. 
  634.     */
  635. {
  636.   if((*argc)-- > 0)
  637.     return(*((*argv)++));
  638.   else
  639.     return(NULL);
  640. }
  641.  
  642. /*----------------------------------------------------------------------*/
  643.  
  644. char *peek_arg(argc,argv)
  645. int *argc;
  646.     char ***argv;
  647.  
  648.      /* Returns the next argument without popping it.
  649.        Returns NULL when it is out of arguments.
  650.        */
  651. {
  652.   if((*argc) > 0)
  653.     return(**argv);
  654.   else
  655.     return(NULL);
  656. }
  657.  
  658. /*----------------------------------------------------------------------*/
  659.  
  660.  
  661. #ifdef THINK_C
  662. #include <EventMgr.h>
  663. #undef MAX_FILE_NAME_LEN 
  664. #ifdef WAIStation
  665. #include "CRetrievalApp.h"
  666. #endif /* def WAIStation */
  667. #endif /* def THINK_C */
  668.  
  669. void
  670. beFriendly()
  671. /* this routine is called during time intensive operations
  672.    on single processing machines (macs and DOS).  It gives
  673.    time to other processes
  674.  */
  675. { 
  676. #ifdef never
  677. #ifdef THINK_C
  678.    EventRecord      macEvent;    /* an event */
  679.  
  680.    static RgnHandle    mouseRgn = NULL; /* region for mouse moved events */
  681.    long                sleepTime;     /* max time between events */
  682.    
  683. #ifdef WAIStation
  684.    gApplication->FrobWaitCursor();
  685. #endif /* def WAIStation */
  686.    
  687.    if (mouseRgn == NULL)
  688.      mouseRgn = NewRgn(); /* do we need to set its value? */
  689.      
  690.    sleepTime = 5; /* arbitrary - a tech note recommends < 50 */
  691.    
  692.    WaitNextEvent(everyEvent,&macEvent,sleepTime,mouseRgn); 
  693. #endif /* def THINK_C */
  694. #endif
  695. }
  696.  
  697. #ifdef BSD
  698. #define NEED_VPRINTF
  699. #endif
  700.  
  701. #ifdef NEED_VPRINTF
  702. /* Portable vsprintf  by Robert A. Larson <blarson@skat.usc.edu> */
  703.  
  704. /* Copyright 1989 Robert A. Larson.
  705.  * Distribution in any form is allowed as long as the author
  706.  * retains credit, changes are noted by their author and the
  707.  * copyright message remains intact.  This program comes as-is
  708.  * with no warentee of fitness for any purpouse.
  709.  *
  710.  * Thanks to Doug Gwen, Chris Torek, and others who helped clarify
  711.  * the ansi printf specs.
  712.  *
  713.  * Please send any bug fixes and improvments to blarson@skat.usc.edu .
  714.  * The use of goto is NOT a bug.
  715.  */
  716.  
  717. /* Feb    7, 1989        blarson        First usenet release */
  718.  
  719. /* This code implements the vsprintf function, without relying on
  720.  * the existance of _doprint or other system specific code.
  721.  *
  722.  * Define NOVOID if void * is not a supported type.
  723.  *
  724.  * Two compile options are available for efficency:
  725.  *    INTSPRINTF    should be defined if sprintf is int and returns
  726.  *            the number of chacters formated.
  727.  *    LONGINT        should be defined if sizeof(long) == sizeof(int)
  728.  *
  729.  *    They only make the code smaller and faster, they need not be
  730.  *    defined.
  731.  *
  732.  * UNSIGNEDSPECIAL should be defined if unsigned is treated differently
  733.  * than int in argument passing.  If this is definded, and LONGINT is not,
  734.  * the compiler must support the type unsingned long.
  735.  *
  736.  * Most quirks and bugs of the available sprintf fuction are duplicated,
  737.  * however * in the width and precision fields will work correctly
  738.  * even if sprintf does not support this, as will the n format.
  739.  *
  740.  * Bad format strings, or those with very long width and precision
  741.  * fields (including expanded * fields) will cause undesired results.
  742.  */
  743.  
  744. #ifdef OSK        /* os9/68k can take advantage of both */
  745. #define LONGINT
  746. #define INTSPRINTF
  747. #endif
  748.  
  749. /* This must be a typedef not a #define! */
  750. #ifdef NOVOID
  751. typedef char *pointer;
  752. #else
  753. typedef void *pointer;
  754. #endif
  755.  
  756. #ifdef    INTSPRINTF
  757. #define Sprintf(string,format,arg)    (sprintf((string),(format),(arg)))
  758. #else
  759. #define Sprintf(string,format,arg)    (\
  760.     sprintf((string),(format),(arg)),\
  761.     strlen(string)\
  762. )
  763. #endif
  764.  
  765. typedef int *intp;
  766.  
  767. int vsprintf(dest, format, args)
  768. char *dest;
  769. register char *format;
  770. va_list args;
  771. {
  772.     register char *dp = dest;
  773.     register char c;
  774.     register char *tp;
  775.     char tempfmt[64];
  776. #ifndef LONGINT
  777.     int longflag;
  778. #endif
  779.  
  780.     tempfmt[0] = '%';
  781.     while( (c = *format++) != 0) {
  782.     if(c=='%') {
  783.         tp = &tempfmt[1];
  784. #ifndef LONGINT
  785.         longflag = 0;
  786. #endif
  787. continue_format:
  788.         switch(c = *format++) {
  789.         case 's':
  790.             *tp++ = c;
  791.             *tp = '\0';
  792.             dp += Sprintf(dp, tempfmt, va_arg(args, char *));
  793.             break;
  794.         case 'u':
  795.         case 'x':
  796.         case 'o':
  797.         case 'X':
  798. #ifdef UNSIGNEDSPECIAL
  799.             *tp++ = c;
  800.             *tp = '\0';
  801. #ifndef LONGINT
  802.             if(longflag)
  803.             dp += Sprintf(dp, tempfmt, va_arg(args, unsigned long));
  804.             else
  805. #endif
  806.             dp += Sprintf(dp, tempfmt, va_arg(args, unsigned));
  807.             break;
  808. #endif
  809.         case 'd':
  810.         case 'c':
  811.         case 'i':
  812.             *tp++ = c;
  813.             *tp = '\0';
  814. #ifndef LONGINT
  815.             if(longflag)
  816.             dp += Sprintf(dp, tempfmt, va_arg(args, long));
  817.             else
  818. #endif
  819.             dp += Sprintf(dp, tempfmt, va_arg(args, int));
  820.             break;
  821.         case 'f':
  822.         case 'e':
  823.         case 'E':
  824.         case 'g':
  825.         case 'G':
  826.             *tp++ = c;
  827.             *tp = '\0';
  828.             dp += Sprintf(dp, tempfmt, va_arg(args, double));
  829.             break;
  830.         case 'p':
  831.             *tp++ = c;
  832.             *tp = '\0';
  833.             dp += Sprintf(dp, tempfmt, va_arg(args, pointer));
  834.             break;
  835.         case '-':
  836.         case '+':
  837.         case '0':
  838.         case '1':
  839.         case '2':
  840.         case '3':
  841.         case '4':
  842.         case '5':
  843.         case '6':
  844.         case '7':
  845.         case '8':
  846.         case '9':
  847.         case '.':
  848.         case ' ':
  849.         case '#':
  850.         case 'h':
  851.             *tp++ = c;
  852.             goto continue_format;
  853.         case 'l':
  854. #ifndef LONGINT
  855.             longflag = 1;
  856.             *tp++ = c;
  857. #endif
  858.             goto continue_format;
  859.         case '*':
  860.             tp += Sprintf(tp, "%d", va_arg(args, int));
  861.             goto continue_format;
  862.         case 'n':
  863.             *va_arg(args, intp) = dp - dest;
  864.             break;
  865.         case '%':
  866.         default:
  867.             *dp++ = c;
  868.             break;
  869.         }
  870.     } else *dp++ = c;
  871.     }
  872.     *dp = '\0';
  873.     return dp - dest;
  874. }
  875.  
  876.  
  877. int vfprintf(dest, format, args)
  878. FILE *dest;
  879. register char *format;
  880. va_list args;
  881. {
  882.     register char c;
  883.     register char *tp;
  884.     register int count = 0;
  885.     char tempfmt[64];
  886. #ifndef LONGINT
  887.     int longflag;
  888. #endif
  889.  
  890.     tempfmt[0] = '%';
  891.     while(c = *format++) {
  892.     if(c=='%') {
  893.         tp = &tempfmt[1];
  894. #ifndef LONGINT
  895.         longflag = 0;
  896. #endif
  897. continue_format:
  898.         switch(c = *format++) {
  899.         case 's':
  900.             *tp++ = c;
  901.             *tp = '\0';
  902.             count += fprintf(dest, tempfmt, va_arg(args, char *));
  903.             break;
  904.         case 'u':
  905.         case 'x':
  906.         case 'o':
  907.         case 'X':
  908. #ifdef UNSIGNEDSPECIAL
  909.             *tp++ = c;
  910.             *tp = '\0';
  911. #ifndef LONGINT
  912.             if(longflag)
  913.             count += fprintf(dest, tempfmt, va_arg(args, unsigned long));
  914.             else
  915. #endif
  916.             count += fprintf(dest, tempfmt, va_arg(args, unsigned));
  917.             break;
  918. #endif
  919.         case 'd':
  920.         case 'c':
  921.         case 'i':
  922.             *tp++ = c;
  923.             *tp = '\0';
  924. #ifndef LONGINT
  925.             if(longflag)
  926.             count += fprintf(dest, tempfmt, va_arg(args, long));
  927.             else
  928. #endif
  929.             count += fprintf(dest, tempfmt, va_arg(args, int));
  930.             break;
  931.         case 'f':
  932.         case 'e':
  933.         case 'E':
  934.         case 'g':
  935.         case 'G':
  936.             *tp++ = c;
  937.             *tp = '\0';
  938.             count += fprintf(dest, tempfmt, va_arg(args, double));
  939.             break;
  940.         case 'p':
  941.             *tp++ = c;
  942.             *tp = '\0';
  943.             count += fprintf(dest, tempfmt, va_arg(args, pointer));
  944.             break;
  945.         case '-':
  946.         case '+':
  947.         case '0':
  948.         case '1':
  949.         case '2':
  950.         case '3':
  951.         case '4':
  952.         case '5':
  953.         case '6':
  954.         case '7':
  955.         case '8':
  956.         case '9':
  957.         case '.':
  958.         case ' ':
  959.         case '#':
  960.         case 'h':
  961.             *tp++ = c;
  962.             goto continue_format;
  963.         case 'l':
  964. #ifndef LONGINT
  965.             longflag = 1;
  966.             *tp++ = c;
  967. #endif
  968.             goto continue_format;
  969.         case '*':
  970.             tp += Sprintf(tp, "%d", va_arg(args, int));
  971.             goto continue_format;
  972.         case 'n':
  973.             *va_arg(args, intp) = count;
  974.             break;
  975.         case '%':
  976.         default:
  977.             putc(c, dest);
  978.             count++;
  979.             break;
  980.         }
  981.     } else {
  982.         putc(c, dest);
  983.         count++;
  984.     }
  985.     }
  986.     return count;
  987. }
  988.  
  989. vprintf(format, args)
  990. char *format;
  991. va_list args;
  992. {
  993.     return vfprintf(stdout, format, args);
  994. }
  995.  
  996. #endif
  997.  
  998.  
  999. /*----------------------------------------------------------------------*/
  1000.